home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 11 / CU Amiga Magazine's Super CD-ROM 11 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-06].iso / cucd / graphics / mpimage / si / apack.asm next >
Assembly Source File  |  1995-04-06  |  8KB  |  251 lines
  1.  
  2. **************************************************************** 
  3. * 
  4. *  Copyright 1988 by CREATIVE FOCUS.  This code is freely 
  5. *  distributable as long as this notice is retained and no 
  6. *  other conditions are imposed upon its redistribution. 
  7. * 
  8. * 
  9. *  APACK.ASM --  
  10. * 
  11. *  A fully compatible replacement for Electronic Arts' PACKER.C 
  12. *  routine.  Converts data according to the IFF ILBM cmpByteRun1 
  13. *  compression protocol: 
  14. * 
  15. *     control bytes: 
  16. * 
  17. *        n =  0.. 127:   followed by n+1 bytes of data; 
  18. *        n = -1..-127:   followed by byte to be repeated -n+1 times; 
  19. *        n =     -128:   don't do no nada. 
  20. * 
  21. *     calling format: 
  22. * 
  23. *        long packrow(from, too, amt) 
  24. *           char **from, /* pointer to source data pointer */ 
  25. *                **too;  /* pointer to destination data pointer */ 
  26. *           long amt;    /* number of bytes to compress */ 
  27. * 
  28. *        return(number of bytes written to destination); 
  29. * 
  30. *     effects: 
  31. * 
  32. *         *from = *from + amt, and *too = *too + return; 
  33. *         return is "smart," that is, not greater than 
  34. *         MaxPackedSize = amt + ((amt+127) >> 7). 
  35. * 
  36. *     By commenting out CHECK (below) you disable checking for runs 
  37. *     exceeding 128 bytes.  That CHECK is not needed if you are sure 
  38. *     the amt to be compressed is always 128 or less. 
  39. * 
  40. *  !!! DISCLAIMER !!!  You use this code entirely at your own 
  41. *  risk.  I don't warrantee its fitness for any purpose.  I 
  42. *  can't even guarantee the accuracy of anything I've said 
  43. *  about it, though I've tried my damndest to get it right. 
  44. *  I may, in fact, be completely out of my tiny little mind :-). 
  45. * 
  46. *  That being said, I can be reached for questions, comments, 
  47. *  or concerns at: 
  48. * 
  49. *        Dr. Gerald Hull 
  50. *        CREATIVE FOCUS 
  51. *        12 White Street 
  52. *        Binghamton, N.Y.  13901 
  53. *        (607) 648-4082 
  54. * 
  55. *        bix:    ghull 
  56. *        PLink:  DRJERRY 
  57. * 
  58. *************************************************************** 
  59.  
  60.       xdef  _packrow 
  61.  
  62. PT    equr  a0                -> beginning of replicate run (if any) 
  63. IX    equr  a1                -> end+1 of input line 
  64. IP    equr  a2                -> beginning of literal run (if any) 
  65. IQ    equr  a3                -> end+1 of lit and/or rep run (if any) 
  66. OP    equr  a4                -> end+1 of output line current pos 
  67. FP    equr  a6                frame pointer 
  68. SP    equr  a7                stack pointer 
  69.  
  70. RT    equr  d0                return value 
  71. MX    equr  d1                check for maximum run = MAX 
  72. AM    equr  d2                amount 
  73. CH    equr  d3                character 
  74.  
  75. REGS  reg   AM/CH/IP/IQ/OP 
  76.  
  77. FRM   equ   8                 input line address 
  78. TOO   equ   12                output line address 
  79. AMT   equ   16                length of input line 
  80.  
  81. MAX   equ   128               maximum encodable output run 
  82. * CHECK equ   1                 turns on maximum row checking 
  83.  
  84.     Section    code,CODE
  85.  
  86. _packrow 
  87.  
  88.  
  89. ***************     CASE 0:   GRAB PARAMS & INITIALIZE 
  90. CAS0 
  91.       link     FP,#0 
  92.       movem.l  REGS,-(SP) 
  93.       movea.l  FRM(FP),IP 
  94.       movea.l  (IP),IP        IP = *from 
  95.       movea.l  IP,IQ          IQ = IP 
  96.       movea.l  IQ,IX 
  97.       adda.l   AMT(FP),IX     IX = IP + amt 
  98.       movea.l  TOO(FP),OP 
  99.       movea.l  (OP),OP        OP = *too 
  100.  
  101.  
  102. ***************     CASE 1:   LITERAL RUN 
  103. CAS1 
  104.       movea.l  IQ,PT          adjust PT (no replicates yet!) 
  105.       move.b   (IQ)+,CH       grab character 
  106.       cmpa.l   IQ,IX          if input is finished 
  107.       beq.s    CAS5              branch to case 5 
  108.  
  109.       ifd      CHECK 
  110.       move.l   IQ,MX 
  111.       sub.l    IP,MX 
  112.       cmpi     #MAX,MX        if run has reached MAX 
  113.       beq.s    CAS6              branch to case 6 
  114.       endc 
  115.  
  116.       cmp.b    (IQ),CH        if next character != CH 
  117.       bne.s    CAS1              stay in case 1 
  118.  
  119. *                             else fall into case 2 
  120.  
  121.  
  122. ***************     CASE 2:   AT LEAST 2 BYTE REPEAT 
  123. CAS2 
  124.       move.b   (IQ)+,CH       grab character 
  125.       cmpa.l   IQ,IX          if input is finished 
  126.       beq.s    CAS7              branch to case 7 
  127.  
  128.       ifd      CHECK 
  129.       move.l   IQ,MX 
  130.       sub.l    IP,MX 
  131.       cmpi     #MAX,MX        if run has reached MAX 
  132.       beq.s    CAS6              branch to case 6 
  133.       endc 
  134.  
  135.       cmp.b    (IQ),CH        if next character != CH 
  136.       bne.s    CAS1              branch to case 1 
  137.  
  138. *                             else fall into case 3 
  139.  
  140.  
  141. ***************     CASE 3:   REPLICATE RUN 
  142. CAS3 
  143.       move.b   (IQ)+,CH       grab character 
  144.       cmpa.l   IQ,IX          if input is finished 
  145.       beq.s    CAS7              branch to case 7 
  146.  
  147.       ifd      CHECK 
  148.       move.l   IQ,MX 
  149.       sub.l    PT,MX 
  150.       cmpi     #MAX,MX        if run has reached MAX 
  151.       beq.s    CAS4              branch to case 4 
  152.       endc 
  153.  
  154.       cmp.b    (IQ),CH        if next character = CH 
  155.       beq.s    CAS3              stay in case 3 
  156.  
  157. *                             else fall into case 4 
  158.  
  159.  
  160. ***************     CASE 4:   LIT AND/OR REP DUMP & CONTINUE 
  161. CAS4 
  162.       move.l   PT,AM 
  163.       sub.l    IP,AM          AM = PT - IP 
  164. *                             if no literal run 
  165.       beq.s    C41               branch to replicate run 
  166.  
  167.       subq     #1,AM          AM = AM - 1 
  168.       move.b   AM,(OP)+       output literal control byte 
  169.  
  170. C40   move.b   (IP)+,(OP)+    output literal run 
  171.       dbra     AM,C40 
  172.  
  173. C41   move.l   PT,AM 
  174.       sub.l    IQ,AM          AM = PT - IQ (negative result!) 
  175.       addq     #1,AM          AM = AM + 1 
  176.       move.b   AM,(OP)+       output replicate control byte 
  177.       move.b   CH,(OP)+       output repeated character 
  178.       movea.l  IQ,IP          reset IP 
  179.       bra.s    CAS1           branch to case 1 (not done) 
  180.  
  181.  
  182. ***************     CASE 5:   LITERAL DUMP & QUIT 
  183. CAS5 
  184.       move.l   IQ,AM 
  185.       sub.l    IP,AM          AM = IQ - IP (positive result > 0) 
  186.       subq     #1,AM          AM = AM - 1 
  187.       move.b   AM,(OP)+       output literal control byte 
  188.  
  189. C50   move.b   (IP)+,(OP)+    output literal run 
  190.       dbra     AM,C50 
  191.  
  192.       bra.s    CAS8           branch to case 8 (done) 
  193.  
  194.  
  195.       ifd      CHECK 
  196.  
  197. ***************     CASE 6:   LITERAL DUMP & CONTINUE 
  198. CAS6 
  199.       move.l   IQ,AM 
  200.       sub.l    IP,AM          AM = IQ - IP (positive result > 0) 
  201.       subq     #1,AM          AM = AM - 1 
  202.       move.b   AM,(OP)+       output literal control byte 
  203.  
  204. C60   move.b   (IP)+,(OP)+    output literal run 
  205.       dbra     AM,C60 
  206.  
  207.       bra      CAS1           branch to case 1 (not done) 
  208.  
  209.       endc 
  210.  
  211.  
  212. ***************     CASE 7:   LIT AND/OR REP DUMP & FINISH 
  213. CAS7 
  214.       move.l   PT,AM 
  215.       sub.l    IP,AM          AM = PT - IP (positive result > 0) 
  216. *                             if no literal run 
  217.       beq.s    C71               branch to replicate run 
  218.  
  219.       subq     #1,AM          AM = AM - 1 
  220.       move.b   AM,(OP)+       output literal control byte 
  221.  
  222. C70   move.b   (IP)+,(OP)+    output literal run 
  223.       dbra     AM,C70 
  224.  
  225. C71   move.l   PT,AM 
  226.       sub.l    IQ,AM          AM = PT - IQ (negative result) 
  227.       addq     #1,AM          AM = AM + 1 
  228.       move.b   AM,(OP)+       output replicate control byte 
  229.       move.b   CH,(OP)+       output repeated character 
  230.  
  231. *                             fall into case 8 
  232.  
  233.  
  234. ***************     CASE 8:   ADJUST PARAMS & RETURN VALUE 
  235. CAS8 
  236.       movea.l  FRM(FP),PT     PT = **from 
  237.       move.l   IQ,(PT)        *from = *from + amt 
  238.       movea.l  TOO(FP),PT     PT = **too 
  239.  
  240.       move.l   OP,RT 
  241.       sub.l    (PT),RT       return = OP - *too  
  242.  
  243.       move.l   OP,(PT)       *too = *too + return 
  244.       movem.l  (SP)+,REGS 
  245.       UNLK     FP 
  246.       rts 
  247.  
  248.       end
  249.  
  250.  
  251.